const BlogType = require('../models/BlogType');
const Blog = require('../models/Blog');

// 博客类型列表接口
exports.getBlogTypes = async (req, res) => {
  try {
    const types = await BlogType.find().select('_id name value');
    res.json({
      errCode: 0,
      errMsg: '获取成功',
      data: types
    });
  } catch (error) {
    console.error('获取博客类型列表失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '获取博客类型列表失败'
    });
  }
};
// 新增博客类型接口
exports.addBlogType = async (req, res) => {
  try {
    const { name, value } = req.body;
    if (!name || !value) {
      return res.status(200).json({
        errCode: 'b004',
        errMsg: '名称和值为必填项'
      });
    }
    const type = new BlogType({
      name,
      value
    });
    await type.save();
    res.json({
      errCode: 0,
      errMsg: '新增成功',
      data: type
    });
  } catch (error) {
    console.error('新增博客类型失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '新增博客类型失败'
    });
  }
};
// 编辑博客类型接口
exports.editBlogType = async (req, res) => {
  try {
    const { _id, name, value } = req.body;
    if (!_id || !name || !value) {
      return res.status(200).json({
        errCode: 'b004',
        errMsg: 'ID、名称和值为必填项'
      });
    }
    const type = await BlogType.findByIdAndUpdate(
      _id,
      { name, value },
      { new: true, runValidators: true }
    );
    if (!type) {
      return res.status(200).json({
        errCode: 'b003',
        errMsg: '博客类型不存在'
      });
    }
    res.json({
      errCode: 0,
      errMsg: '编辑成功',
      data: type
    });
  } catch (error) {
    console.error('编辑博客类型失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '编辑博客类型失败'
    });
  }
}
// 删除博客类型接口
exports.delBlogType = async (req, res) => {
  try {
    const { _id } = req.body;
    if (!_id) {
      return res.status(200).json({
        errCode: 'b004',
        errMsg: 'ID为必填项'
      });
    }
    const type = await BlogType.findByIdAndDelete(_id);
    if (!type) {
      return res.status(200).json({
        errCode: 'b003',
        errMsg: '博客类型不存在'
      });
    }
    res.json({
      errCode: 0,
      errMsg: '删除成功',
      data: type
    });
  } catch (error) {
    console.error('删除博客类型失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '删除博客类型失败'
    });
  }
}



// 新增/编辑博客接口
exports.addBlog = async (req, res) => {
  try {
    const { title, type, content, status } = req.body;
    console.log("新增博客s",title, type, content, status)
    // 验证必填字段
    if (!title || !type || !content) {
      return res.status(200).json({
        errCode: 'b001',
        errMsg: '标题、类型和内容为必填项'
      });
    }
    // 新增博客
      blog = new Blog({
        title,
        type,
        content,
        status: status || '1'
      });
      await blog.save();
      res.json({
        errCode: 0,
        errMsg: '新增成功',
        data: blog
      });
  } catch (error) {
    console.error('保存博客失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '保存博客失败'
    });
  }
}
exports.saveBlog = async (req, res) => {
  try {
    const { _id, title, type, content, status } = req.body;
    console.log("新增博客s",_id, title, type, content, status)
    // 验证必填字段
    if (!title || !type || !content) {
      return res.status(200).json({
        errCode: 'b001',
        errMsg: '标题、类型和内容为必填项'
      });
    }
    
    let blog;
      // 编辑博客
      blog = await Blog.findByIdAndUpdate(
        _id,
        { title, type, content, status },
        { new: true, runValidators: true }
      );
      
      if (!blog) {
        return res.status(200).json({
          errCode: 'b003',
          errMsg: '博客不存在'
        });
      }
    
    
    res.json({
      errCode: 0,
      errMsg: '编辑成功',
      data: blog
    });
  } catch (error) {
    console.error('保存博客失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '保存博客失败'
    });
  }
};

// 博客列表接口
exports.getBlogs = async (req, res) => {
  try {
    const { title, type, page = 1, pageSize = 10 } = req.body;
    
    const query = {};
    
    // 标题模糊查询
    if (title) {
      query.title = { $regex: title, $options: 'i' };
    }
    
    // 类型筛选
    if (type) {
      query.type = type;
    }
    
    // 分页查询
    const skip = (page - 1) * pageSize;
    const blogs = await Blog.find(query)
      .populate('type', 'name value typeName')
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(Number(pageSize));
    const types = await BlogType.find().select('_id name value');
    // console.log("sdsds111",types)
    blogs.map(item => {
      item.typeName = types.find(type => type.value === item.type)?.name || '';
    })
    // console.log("sdsds222",blogs)
    const total = await Blog.countDocuments(query);
    
    res.json({
      errCode: 0,
      errMsg: '获取成功',
      data: {
        list: blogs,
        total,
        page: Number(page),
        pageSize: Number(pageSize)
      }
    });
  } catch (error) {
    console.error('获取博客列表失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '获取博客列表失败'
    });
  }
};

// 删除博客接口
exports.deleteBlog = async (req, res) => {
  try {
    const { _id } = req.body;
    
    const blog = await Blog.findByIdAndDelete(_id);
    
    if (!blog) {
      return res.status(200).json({
        errCode: 'b003',
        errMsg: '博客不存在'
      });
    }
    
    res.json({
      errCode: 0,
      errMsg: '删除成功'
    });
  } catch (error) {
    console.error('删除博客失败:', error);
    res.status(500).json({
      errCode: 500,
      errMsg: error.message || '删除博客失败'
    });
  }
};